package com.xxxx.server.service.impl;


import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xxxx.server.entity.CompletionStatus;
import com.xxxx.server.entity.Course;
import com.xxxx.server.entity.Notice;
import com.xxxx.server.entity.StudentTranscript;
import com.xxxx.server.mapper.AdminMapper;
import com.xxxx.server.mapper.course.CourseMapper;
import com.xxxx.server.pojo.Admin;
import com.xxxx.server.pojo.RespBean;
import com.xxxx.server.pojo.RespPageBean;
import com.xxxx.server.service.CourseService;
import com.xxxx.server.utils.AdminUtils;
import com.xxxx.server.utils.FileUtils;
import com.xxxx.server.utils.PoiXslUtils;
import com.xxxx.server.vo.CourseTaskVO;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * @author SR
 * @description 针对表【course】的数据库操作Service实现
 * @createDate 2021-11-13 16:21:23
 */
@Service
public class CourseServiceImpl extends ServiceImpl<CourseMapper, Course> implements CourseService {

    @Resource
    CourseMapper courseMapper;

    @Resource
    AdminMapper adminMapper;

    /**
     * 课程分页
     *
     * @param currentPage
     * @param size
     * @param text
     */
    public RespPageBean getPage(Integer currentPage, Integer size, String text, Integer userId) {
        if (!StringUtils.isEmpty(text)) {
            text = "%" + text + "%";
        }
        // 开启分页
        Page<Course> page = new Page<>(currentPage, size);
        IPage<Course> employeePage = courseMapper.getPage(page, text, userId);
        // 分页记录
        List<Course> records = employeePage.getRecords();
        // employeePage.getTotal() 总记录数， employeePage.getRecords() 查询出来的集合(记录)
        return new RespPageBean(employeePage.getTotal(), records);
    }

    /**
     * 名称查询
     *
     * @param title
     */
    public Course getByTitle(String title) {
        return courseMapper.getByTitle(title);
    }

    /**
     * id查询
     *
     * @param itm_id
     * @return
     */
    public Course getCourseById(Integer itm_id) {
        return courseMapper.getCourseById(itm_id);
    }

    /**
     * @param course
     * @return
     */
    public int updateCourseById(Course course) {
        return courseMapper.updateCourseById(course);
    }

    /**
     * id删除
     *
     * @param id
     * @return
     */
    public int deleteById(Integer id) {
        return courseMapper.deleteCourseById(id);
    }

    /**
     * 批量导入
     *
     * @param multipartFile
     * @return
     */
    public RespBean batchImport(MultipartFile multipartFile) throws IOException {
        if (multipartFile != null && !StringUtils.isEmpty(multipartFile.getOriginalFilename())) {
            // 检验文件格式
            boolean b = PoiXslUtils.checkIsExcel(multipartFile.getOriginalFilename());
            if (b) {
                return RespBean.error("只能上传excel文件！");
            }
        }
        // 记录错误的数据
        List<String> errList = new ArrayList<>();
        // 生成文件到临时目录
        String filePath = FileUtils.uploadFileTemp(multipartFile);
        // 解析文件，第一个list是标题集合
        List<List<String>> rowList = PoiXslUtils.readExcel(filePath);
        // 模板标题
        List<String> list = new ArrayList<>();
        list.add("课程名称");
        list.add("学生学号");
        // 文件是否为空
        if (CollectionUtils.isEmpty(rowList) || rowList.size() == list.size()) {
            return RespBean.error("模板文件内容不能为空！");
        }
        // 判断集合标题是否相同
        if (rowList.get(0).containsAll(list)) {
            // 从第二个数据行开始遍历(第一个集合是标题行)
            for (int i = 1; i < rowList.size(); i++) {
                // 获取列值
                List<String> valueList = rowList.get(i);
                // 课程名称
                String title = valueList.get(0);
                Course byTitle = courseMapper.getByTitle(title);
                if (StringUtils.isEmpty(byTitle)) {
                    // 报错
                    errList.add("课程为【" + title + "】的课程不存在！");
                }
                // 学生学号
                String number = valueList.get(1);
                Admin exist = adminMapper.getAdmin(number);
                // 判断学号
                if (StringUtils.isEmpty(exist)) {
                    // 报错
                    errList.add("学号为【" + number + "】的学生不存在！");
                }

                // 添加课程与学生的关系
                if (!StringUtils.isEmpty(byTitle) && !StringUtils.isEmpty(exist)) {
                    Integer enroll = courseMapper.isEnroll(byTitle.getItm_id(), exist.getId());
                    if (null != enroll && enroll > 0) {
                        errList.add("学号为【" + number + "】的学生已经报名了" + title + "！");
                    } else {
                        courseMapper.addEnroll(byTitle.getItm_id(), exist.getId());
                    }
                }
            }
        } else {
            return RespBean.error("模板文件格式不正确，请重新下载模板文件在提交！");
        }
        // 添加错误记录
        for (String errInfo : errList) {
            adminMapper.addErrorRecord(errInfo, "course");
        }
        // 没有不删除
        if (!StringUtils.isEmpty(filePath)) {
            // 删除文件
            FileUtils.deleteFile(filePath);
        }
        return RespBean.success("添加成功，请查看导入记录有无错误数据！");
    }

    public RespBean getTemplate(String path) {
        // 模板文件路径
        String filePath = FileUtils.getAbsPath() + "enroll_template.xlsx";
        // 创建文件夹
        path = "D:" + File.separator + "教学系统文件夹" + File.separator;
        File file = new File(path);
        if (!file.exists()) {//如果文件夹不存在
            file.mkdir();//创建文件夹
        }

        FileUtils.fileCopy(filePath, path + "学生报名模板-" + System.currentTimeMillis() + ".xlsx");
        return RespBean.success("文件已下载至磁盘--》" + path);
    }

    /**
     * 添加作业
     *
     * @param name
     */
    public void addCourseTask(Integer itmId, String name, String title) {
        courseMapper.addCourseTask(itmId, name, title);
    }

    /**
     * 作业分页
     *
     * @param currentPage
     * @param size
     * @param text
     * @return
     */
    public RespPageBean courseTaskPage(Integer currentPage, Integer size, String text, Integer itmId) {
        if (!StringUtils.isEmpty(text)) {
            text = "%" + text + "%";
        }
        // 开启分页
        Page<CourseTaskVO> page = new Page<>(currentPage, size);
        IPage<CourseTaskVO> employeePage = courseMapper.getCourseTaskPage(page, text, itmId);
        // 分页记录
        List<CourseTaskVO> records = employeePage.getRecords();
        // employeePage.getTotal() 总记录数， employeePage.getRecords() 查询出来的集合(记录)
        return new RespPageBean(employeePage.getTotal(), records);
    }

    /**
     * 修改作业
     *
     * @param tk_id
     * @param name
     */
    public void updateCourseTask(Integer tk_id, String name, String title) {
        courseMapper.updateCourseTask(tk_id, name, title);
    }

    /**
     * 提交作业
     */
    public RespBean submitCourseTask(CompletionStatus completionStatus) {

        if (!StringUtils.isEmpty(courseMapper.getIsExist(completionStatus.getCs_tk_id(), AdminUtils.getCurrentAdmin().getId()))) {
            return RespBean.error("提交失败，每个作业只能提交一次！");
        }
        // 提交人
        completionStatus.setCs_user_id(AdminUtils.getCurrentAdmin().getId());
        courseMapper.submitCourseTask(completionStatus);
        return RespBean.success("提交成功");
    }

    /**
     * 学生作业分页
     *
     * @param currentPage
     * @param size
     * @param text
     * @param tkId
     * @return
     */
    public RespPageBean submitTaskPage(Integer currentPage, Integer size, String text, Integer tkId) {
        if (!StringUtils.isEmpty(text)) {
            text = "%" + text + "%";
        }
        // 开启分页
        Page<CompletionStatus> page = new Page<>(currentPage, size);
        IPage<CompletionStatus> employeePage = courseMapper.submitTaskPage(page, text, tkId);
        // 分页记录
        List<CompletionStatus> records = employeePage.getRecords();
        // employeePage.getTotal() 总记录数， employeePage.getRecords() 查询出来的集合(记录)
        return new RespPageBean(employeePage.getTotal(), records);
    }

    /**
     * 打分
     *
     * @param score
     * @param csId
     * @return
     */
    public void taskScore(Integer score, Integer csId) {
        courseMapper.taskScore(score, csId);
    }

    /**
     * 手动报名
     *
     * @param itmId
     * @param username
     * @return
     */
    public int manualEnroll(Integer itmId, String username) {
        Admin admin = adminMapper.getAdmin(username);
        // 是否已经报名该课程
        Integer enroll = courseMapper.isEnroll(itmId, admin.getId());
        if (null != enroll && enroll > 0) {
            return 0;
        }
        courseMapper.addEnroll(itmId, admin.getId());
        return 1;
    }

    /**
     * 课程是否布置作业
     *
     * @param id
     */
    public Integer getIsRegistered(Integer id) {
        return courseMapper.getIsRegistered(id);
    }

    /**
     * 是否有学生报名
     *
     * @param id
     * @return
     */
    public Integer getIsStudent(Integer id) {
        return courseMapper.getIsStudent(id);
    }

    /**
     * 成绩分页
     *
     * @param currentPage
     * @param size
     * @param text
     * @return
     */
    public RespPageBean getStudentTranscript(Integer currentPage, Integer size, String text, Integer userId, Integer itmId) {
        if (!StringUtils.isEmpty(text)) {
            text = "%" + text + "%";
        }
        // 开启分页
        Page<CompletionStatus> page = new Page<>(currentPage, size);
        IPage<CompletionStatus> employeePage = courseMapper.getStudentTranscript(page, text, userId, itmId);
        // 分页记录
        List<CompletionStatus> records = employeePage.getRecords();
        // employeePage.getTotal() 总记录数， employeePage.getRecords() 查询出来的集合(记录)
        return new RespPageBean(employeePage.getTotal(), records);
    }

    /**
     * 无作业记录
     *
     * @param id
     * @return
     */
    public Integer getIsStuSubmitTK(Integer id) {
        return courseMapper.getIsStuSubmitTK(id);
    }

    /**
     * 未打分记录
     *
     * @param id
     * @return
     */
    public Integer getWithScoreNull(Integer id) {
        return courseMapper.getWithScoreNull(id);
    }

    /**
     * 获取课程学生
     *
     * @param itm_id
     */
    public List<Integer> getUserIdsByItmId(Integer itm_id) {
        return courseMapper.getUserIdsByItmId(itm_id);
    }

    /**
     * 获取学生各种分数
     *
     * @param userId
     */
    public List<CompletionStatus> getUserVariousScores(Integer itmId, Integer userId) {
        return courseMapper.getUserVariousScores(itmId, userId);
    }

    /**
     * 获取作业总数
     *
     * @param itm_id
     */
    public int getTKCountByItmId(Integer itm_id) {
        return courseMapper.getTKCountByItmId(itm_id);
    }

    /**
     * 添加学生总成绩
     *
     * @param studentTranscript
     */
    public void addStudentTranscript(StudentTranscript studentTranscript) {
        courseMapper.addStudentTranscript(studentTranscript);
    }

    /**
     * 发布，修改通知
     *
     * @param notice
     */
    public RespBean addOrUpdateNotice(Notice notice) {
        Admin currentAdmin = AdminUtils.getCurrentAdmin();
        if (null != notice.getNicId() && notice.getNicId() > 0) {
            courseMapper.updateNotice(notice);
            return RespBean.success("修改成功！");
        } else {
            notice.setNicId(currentAdmin.getId());
            courseMapper.addNotice(notice);
            return RespBean.success("添加成功！");
        }
    }

    /**
     * 删除通知
     *
     * @param nicId
     * @return
     */
    public RespBean deleteNotice(Integer nicId) {
        courseMapper.deleteNotice(nicId);
        return RespBean.success("删除成功!");
    }

    /**
     * 通知分页
     *
     * @param currentPage
     * @param size
     * @return
     */
    public RespPageBean getNoticePage(Integer currentPage, Integer size) {
        // 开启分页
        Page<Notice> page = new Page<>(currentPage, size);
        IPage<Notice> employeePage = courseMapper.getNoticePage(page);
        // 分页记录
        List<Notice> records = employeePage.getRecords();
        // employeePage.getTotal() 总记录数， employeePage.getRecords() 查询出来的集合(记录)
        return new RespPageBean(employeePage.getTotal(), records);
    }

    /**
     * 学员端
     *
     * @return
     */
    public List<Notice> getList() {
        return courseMapper.getList();
    }

    /**
     * 个人中心-通知
     *
     * @return
     */
    public Notice maxNotice() {
        // 最大id
        int maxId = courseMapper.getMaxId();
        // 通过最大id找到最新通知
        return courseMapper.maxNotice(maxId);
    }

    /**
     * 找出课程关联的学生
     *
     * @param itmId
     * @return
     */
    public List<StudentTranscript> getExportDataByItmId(Integer itmId) {
        return courseMapper.getExportDataByItmId(itmId);
    }
}
